home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gdevmrop.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-31  |  34.0 KB  |  1,104 lines
  1. /* Copyright (C) 1995, 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gdevmrop.c */
  20. /* RasterOp / transparency / render algorithm implementation for */
  21. /* memory devices */
  22. #include "memory_.h"
  23. #include "gx.h"
  24. #include "gsbittab.h"
  25. #include "gserrors.h"
  26. #include "gsropt.h"
  27. #include "gxdcolor.h"
  28. #include "gxdevice.h"
  29. #include "gxdevmem.h"
  30. #include "gxdevrop.h"
  31. #include "gdevmrop.h"
  32.  
  33. /* Define whether we implement transparency correctly, or whether we */
  34. /* implement it as documented in the H-P manuals. */
  35. #define TRANSPARENCY_PER_H_P
  36.  
  37. /**************** NOTE: ****************
  38.  * The 2- and 4-bit cases don't handle transparency right.
  39.  * The 8- and 24-bit cases haven't been tested.
  40.  * The 16- and 32-bit cases aren't implemented.
  41.  ***************** ****************/
  42.  
  43. #define mdev ((gx_device_memory *)dev)
  44.  
  45. /* Forward references */
  46. private gs_rop3_t gs_transparent_rop(P1(gs_logical_operation_t lop));
  47.  
  48. #define chunk byte
  49.  
  50. /* Calculate the X offset for a given Y value, */
  51. /* taking shift into account if necessary. */
  52. #define x_offset(px, ty, textures)\
  53.   ((textures)->shift == 0 ? (px) :\
  54.    (px) + (ty) / (textures)->rep_height * (textures)->rep_shift)
  55.  
  56. /* ---------------- Initialization ---------------- */
  57.  
  58. void
  59. gs_roplib_init(gs_memory_t *mem)
  60. {    /* Replace the default and forwarding copy_rop procedures. */
  61.     gx_default_copy_rop_proc = gx_real_default_copy_rop;
  62.     gx_forward_copy_rop_proc = gx_forward_copy_rop;
  63.     gx_default_strip_copy_rop_proc = gx_real_default_strip_copy_rop;
  64.     gx_forward_strip_copy_rop_proc = gx_forward_strip_copy_rop;
  65. }
  66.  
  67. /* ---------------- Debugging aids ---------------- */
  68.  
  69. #ifdef DEBUG
  70.  
  71. private void
  72. trace_copy_rop(const char *cname, gx_device *dev,
  73.   const byte *sdata, int sourcex, uint sraster, gx_bitmap_id id,
  74.   const gx_color_index *scolors,
  75.   const gx_strip_bitmap *textures, const gx_color_index *tcolors,
  76.   int x, int y, int width, int height,
  77.   int phase_x, int phase_y, gs_logical_operation_t lop)
  78. {    dprintf4("%s: dev=0x%lx(%s) depth=%d\n",
  79.          cname, (ulong)dev, dev->dname, dev->color_info.depth);
  80.     dprintf4("  source data=0x%lx x=%d raster=%u id=%lu colors=",
  81.          (ulong)sdata, sourcex, sraster, (ulong)id);
  82.     if ( scolors )
  83.       dprintf2("(%lu,%lu);\n", scolors[0], scolors[1]);
  84.     else
  85.       dputs("none;\n");
  86.     if ( textures )
  87.       dprintf8("  textures=0x%lx size=%dx%d(%dx%d) raster=%u shift=%d(%d)",
  88.            (ulong)textures, textures->size.x, textures->size.y,
  89.            textures->rep_width, textures->rep_height, textures->raster,
  90.            textures->shift, textures->rep_shift);
  91.     else
  92.       dputs("  textures=none");
  93.     if ( tcolors )
  94.       dprintf2(" colors=(%lu,%lu)\n", tcolors[0], tcolors[1]);
  95.     else
  96.       dputs(" colors=none\n");
  97.     dprintf7("  rect=(%d,%d),(%d,%d) phase=(%d,%d) op=0x%x\n",
  98.          x, y, x + width, y + height, phase_x, phase_y,
  99.          (uint)lop);
  100.     if ( gs_debug_c('B') )
  101.     { if ( sdata )
  102.         debug_dump_bitmap(sdata, sraster, height, "source bits");
  103.       if ( textures && textures->data )
  104.         debug_dump_bitmap(textures->data, textures->raster,
  105.                   textures->size.y, "textures bits");
  106.     }
  107. }
  108.  
  109. #endif
  110.  
  111. /* ---------------- Monobit RasterOp ---------------- */
  112.  
  113. int
  114. mem_mono_strip_copy_rop(gx_device *dev,
  115.   const byte *sdata, int sourcex, uint sraster, gx_bitmap_id id,
  116.   const gx_color_index *scolors,
  117.   const gx_strip_bitmap *textures, const gx_color_index *tcolors,
  118.   int x, int y, int width, int height,
  119.   int phase_x, int phase_y, gs_logical_operation_t lop)
  120. {    gs_rop3_t rop = gs_transparent_rop(lop); /* handle transparency */
  121.     gx_strip_bitmap no_texture;
  122.     bool invert;
  123.     uint draster = mdev->raster;
  124.     uint traster;
  125.     int line_count;
  126.     byte *drow;
  127.     const byte *srow;
  128.     int ty;
  129.  
  130.     /* If map_rgb_color isn't the default one for monobit memory */
  131.     /* devices, palette might not be set; set it now if needed. */
  132.     if ( mdev->palette.data == 0 )
  133.       gdev_mem_mono_set_inverted(mdev,
  134.                      (*dev_proc(dev, map_rgb_color))
  135.                        (dev, (gx_color_value)0,
  136.                        (gx_color_value)0, (gx_color_value)0)
  137.                       != 0);
  138.     invert = mdev->palette.data[0] != 0;
  139.  
  140. #ifdef DEBUG
  141.     if ( gs_debug_c('b') )
  142.       trace_copy_rop("mem_mono_strip_copy_rop",
  143.              dev, sdata, sourcex, sraster,
  144.              id, scolors, textures, tcolors,
  145.              x, y, width, height, phase_x, phase_y, lop);
  146.     if ( gs_debug_c('B') )
  147.       debug_dump_bitmap(scan_line_base(mdev, y), mdev->raster,
  148.                 height, "initial dest bits");
  149. #endif
  150.  
  151.     /*
  152.      * RasterOp is defined as operating in RGB space; in the monobit
  153.      * case, this means black = 0, white = 1.  However, most monobit
  154.      * devices use the opposite convention.  To make this work,
  155.      * we must precondition the Boolean operation by swapping the
  156.      * order of bits end-for-end and then inverting.
  157.      */
  158.  
  159.     if ( invert )
  160.       rop = byte_reverse_bits[rop] ^ 0xff;
  161.  
  162.     /*
  163.      * From this point on, rop works in terms of device pixel values,
  164.      * not RGB-space values.
  165.      */
  166.  
  167.     /* Modify the raster operation according to the source palette. */
  168.     if ( scolors != 0 )
  169.     {    /* Source with palette. */
  170.         switch ( (int)((scolors[1] << 1) + scolors[0]) )
  171.         {
  172.         case 0: rop = rop3_know_S_0(rop); break;
  173.         case 1: rop = rop3_invert_S(rop); break;
  174.         case 2: break;
  175.         case 3: rop = rop3_know_S_1(rop); break;
  176.         }
  177.     }
  178.  
  179.     /* Modify the raster operation according to the texture palette. */
  180.     if ( tcolors != 0 )
  181.     {    /* Texture with palette. */
  182.         switch ( (int)((tcolors[1] << 1) + tcolors[0]) )
  183.         {
  184.         case 0: rop = rop3_know_T_0(rop); break;
  185.         case 1: rop = rop3_invert_T(rop); break;
  186.         case 2: break;
  187.         case 3: rop = rop3_know_T_1(rop); break;
  188.         }
  189.     }
  190.  
  191.     /* Handle constant source and/or texture, and other special cases. */
  192.     { gx_color_index color0, color1;
  193.  
  194.     switch ( rop_usage_table[rop] )
  195.       {
  196.       case rop_usage_none:
  197.         /* We're just filling with a constant. */
  198.         return (*dev_proc(dev, fill_rectangle))
  199.           (dev, x, y, width, height, (gx_color_index)(rop & 1));
  200.       case rop_usage_D:
  201.         /* This is either D (no-op) or ~D. */
  202.         if ( rop == rop3_D )
  203.           return 0;
  204.         /* Code no_S inline, then finish with no_T. */
  205.         fit_fill(dev, x, y, width, height);
  206.         sdata = mdev->base;
  207.         sourcex = x;
  208.         sraster = 0;
  209.         goto no_T;
  210.       case rop_usage_S:
  211.         /* This is either S or ~S, which copy_mono can handle. */
  212.         if ( rop == rop3_S )
  213.           color0 = 0, color1 = 1;
  214.         else
  215.           color0 = 1, color1 = 0;
  216. do_copy:    return (*dev_proc(dev, copy_mono))
  217.           (dev, sdata, sourcex, sraster, id, x, y, width, height,
  218.            color0, color1);
  219.       case rop_usage_DS:
  220.         /* This might be a case that copy_mono can handle. */
  221. #define copy_case(c0, c1) color0 = c0, color1 = c1; goto do_copy;
  222.         switch ( (uint)rop ) /* cast shuts up picky compilers */
  223.           {
  224.           case rop3_D & rop3_not(rop3_S): copy_case(gx_no_color_index, 0);
  225.           case rop3_D | rop3_S: copy_case(gx_no_color_index, 1);
  226.           case rop3_D & rop3_S: copy_case(0, gx_no_color_index);
  227.           case rop3_D | rop3_not(rop3_S): copy_case(1, gx_no_color_index);
  228.           default: ;
  229.           }
  230. #undef copy_case
  231.         fit_copy(dev, sdata, sourcex, sraster, id, x, y, width, height);
  232. no_T:        /* Texture is not used; textures may be garbage. */
  233.         no_texture.data = mdev->base;    /* arbitrary */
  234.         no_texture.raster = 0;
  235.         no_texture.size.x = width;
  236.         no_texture.size.y = height;
  237.         no_texture.rep_width = no_texture.rep_height = 1;
  238.         no_texture.rep_shift = no_texture.shift = 0;
  239.         textures = &no_texture;
  240.         break;
  241.       case rop_usage_T:
  242.         /* This is either T or ~T, which tile_rectangle can handle. */
  243.         if ( rop == rop3_T )
  244.           color0 = 0, color1 = 1;
  245.         else
  246.           color0 = 1, color1 = 0;
  247. do_tile:    return (*dev_proc(dev, strip_tile_rectangle))
  248.           (dev, textures, x, y, width, height, color0, color1,
  249.            phase_x, phase_y);
  250.       case rop_usage_DT:
  251.         /* This might be a case that tile_rectangle can handle. */
  252. #define tile_case(c0, c1) color0 = c0, color1 = c1; goto do_tile;
  253.         switch ( (uint)rop ) /* cast shuts up picky compilers */
  254.           {
  255.           case rop3_D & rop3_not(rop3_T): tile_case(gx_no_color_index, 0);
  256.           case rop3_D | rop3_T: tile_case(gx_no_color_index, 1);
  257.           case rop3_D & rop3_T: tile_case(0, gx_no_color_index);
  258.           case rop3_D | rop3_not(rop3_T): tile_case(1, gx_no_color_index);
  259.           default: ;
  260.           }
  261. #undef tile_case
  262.         fit_fill(dev, x, y, width, height);
  263.         /* Source is not used; sdata et al may be garbage. */
  264.         sdata = mdev->base;        /* arbitrary, as long as all */
  265.                     /* accesses are valid */
  266.         sourcex = x;        /* guarantee no source skew */
  267.         sraster = 0;
  268.         break;
  269.       default:        /* rop_usage_[D]ST */
  270.         fit_copy(dev, sdata, sourcex, sraster, id, x, y, width, height);
  271.       }
  272.     }
  273.  
  274. #ifdef DEBUG
  275.     if_debug1('b', "final rop=0x%x\n", rop);
  276. #endif
  277.  
  278.     /* Set up transfer parameters. */
  279.     line_count = height;
  280.     srow = sdata;
  281.     drow = scan_line_base(mdev, y);
  282.     traster = textures->raster;
  283.     ty = y + phase_y;
  284.  
  285.     /* Loop over scan lines. */
  286.     for ( ; line_count-- > 0; drow += draster, srow += sraster, ++ty )
  287.     {    int sx = sourcex;
  288.         int dx = x;
  289.         int w = width;
  290.         const byte *trow =
  291.           textures->data + (ty % textures->rep_height) * traster;
  292.         int xoff = x_offset(phase_x, ty, textures);
  293.         int nw;
  294.  
  295.         /* Loop over (norizontal) copies of the tile. */
  296.         for ( ; w > 0; sx += nw, dx += nw, w -= nw )
  297.         {    int dbit = dx & 7;
  298.             int sbit = sx & 7;
  299.             int sskew = sbit - dbit;
  300.             int tx = (dx + xoff) % textures->rep_width;
  301.             int tbit = tx & 7;
  302.             int tskew = tbit - dbit;
  303.             int left = nw = min(w, textures->size.x - tx);
  304.             byte lmask = 0xff >> dbit;
  305.             byte rmask = 0xff << (~(dbit + nw - 1) & 7);
  306.             byte mask = lmask;
  307.             int nx = 8 - dbit;
  308.             byte *dptr = drow + (dx >> 3);
  309.             const byte *sptr = srow + (sx >> 3);
  310.             const byte *tptr = trow + (tx >> 3);
  311.  
  312.             if ( sskew < 0 )
  313.               --sptr, sskew += 8;
  314.             if ( tskew < 0 )
  315.               --tptr, tskew += 8;
  316.             for ( ; left > 0;
  317.                   left -= nx, mask = 0xff, nx = 8,
  318.                     ++dptr, ++sptr, ++tptr
  319.                 )
  320.                 {    byte dbyte = *dptr;
  321. #define fetch1(ptr, skew)\
  322.   (skew ? (ptr[0] << skew) + (ptr[1] >> (8 - skew)) : *ptr)
  323.                 byte sbyte = fetch1(sptr, sskew);
  324.                 byte tbyte = fetch1(tptr, tskew);
  325. #undef fetch1
  326.                 byte result =
  327.                   (*rop_proc_table[rop])(dbyte, sbyte, tbyte);
  328.                 if ( left <= nx )
  329.                   mask &= rmask;
  330.                 *dptr = (mask == 0xff ? result :
  331.                      (result & mask) | (dbyte & ~mask));
  332.              }
  333.         }
  334.     }
  335. #ifdef DEBUG
  336.     if ( gs_debug_c('B') )
  337.       debug_dump_bitmap(scan_line_base(mdev, y), mdev->raster,
  338.                 height, "final dest bits");
  339. #endif
  340.     return 0;
  341. }
  342.  
  343. /* ---------------- Fake RasterOp for 2- and 4-bit devices ---------------- */
  344.  
  345. int
  346. mem_gray_strip_copy_rop(gx_device *dev,
  347.   const byte *sdata, int sourcex, uint sraster, gx_bitmap_id id,
  348.   const gx_color_index *scolors,
  349.   const gx_strip_bitmap *textures, const gx_color_index *tcolors,
  350.   int x, int y, int width, int height,
  351.   int phase_x, int phase_y, gs_logical_operation_t lop)
  352. {    gx_color_index scolors2[2];
  353.     const gx_color_index *real_scolors = scolors;
  354.     gx_color_index tcolors2[2];
  355.     const gx_color_index *real_tcolors = tcolors;
  356.     gx_strip_bitmap texture2;
  357.     const gx_strip_bitmap *real_texture = textures;
  358.     long tdata;
  359.     int depth = dev->color_info.depth;
  360.     int log2_depth = depth >> 1;        /* works for 2, 4 */
  361.     gx_color_index max_pixel = (1 << depth) - 1;
  362.     int code;
  363.  
  364. #ifdef DEBUG
  365.     if ( gs_debug_c('b') )
  366.       trace_copy_rop("mem_gray_strip_copy_rop",
  367.              dev, sdata, sourcex, sraster,
  368.              id, scolors, textures, tcolors,
  369.              x, y, width, height, phase_x, phase_y, lop);
  370. #endif
  371.     if ( scolors )
  372.     {    /* We can't handle "real" source colors. */
  373.         if ( (scolors[0] | scolors[1]) & ~max_pixel )
  374.           return_error(gs_error_rangecheck);
  375.         scolors2[0] = scolors[0] & 1;
  376.         scolors2[1] = scolors[1] & 1;
  377.         real_scolors = scolors2;
  378.     }
  379.     if ( textures )
  380.     {    texture2 = *textures;
  381.         texture2.size.x <<= log2_depth;
  382.         texture2.rep_width <<= log2_depth;
  383.         texture2.shift <<= log2_depth;
  384.         texture2.rep_shift <<= log2_depth;
  385.         real_texture = &texture2;
  386.     }
  387.     if ( tcolors )
  388.     {    /* We can't handle monobit textures. */
  389.         if ( tcolors[0] != tcolors[1] )
  390.           return_error(gs_error_rangecheck);
  391.         /* For polybit textures with colors other than */
  392.         /* all 0s or all 1s, fabricate the data. */
  393.         if ( tcolors[0] != 0 && tcolors[0] != max_pixel )
  394.         {    real_tcolors = 0;
  395.             *(byte *)&tdata = (byte)tcolors[0] << (8 - depth);
  396.             texture2.data = (byte *)&tdata;
  397.             texture2.raster = align_bitmap_mod;
  398.             texture2.size.x = texture2.rep_width = depth;
  399.             texture2.size.y = texture2.rep_height = 1;
  400.             texture2.id = gx_no_bitmap_id;
  401.             texture2.shift = texture2.rep_shift = 0;
  402.             real_texture = &texture2;
  403.         }
  404.         else
  405.         {    tcolors2[0] = tcolors2[1] = tcolors[0] & 1;
  406.             real_tcolors = tcolors2;
  407.         }
  408.     }
  409.     dev->width <<= log2_depth;
  410.     code = mem_mono_strip_copy_rop(dev, sdata,
  411.         (real_scolors == NULL ? sourcex << log2_depth : sourcex),
  412.         sraster, id, real_scolors, real_texture, real_tcolors,
  413.         x << log2_depth, y, width << log2_depth, height,
  414.         phase_x << log2_depth, phase_y, lop);
  415.     dev->width >>= log2_depth;
  416.     return code;
  417. }
  418.  
  419. /* ---------------- RasterOp with 8-bit gray / 24-bit RGB ---------------- */
  420.  
  421. int
  422. mem_gray8_rgb24_strip_copy_rop(gx_device *dev,
  423.   const byte *sdata, int sourcex, uint sraster, gx_bitmap_id id,
  424.   const gx_color_index *scolors,
  425.   const gx_strip_bitmap *textures, const gx_color_index *tcolors,
  426.   int x, int y, int width, int height,
  427.   int phase_x, int phase_y, gs_logical_operation_t lop)
  428. {    gs_rop3_t rop = lop_rop(lop);
  429.     gx_color_index const_source = gx_no_color_index;
  430.     gx_color_index const_texture = gx_no_color_index;
  431.     uint draster = mdev->raster;
  432.     int line_count;
  433.     byte *drow;
  434.     int depth = dev->color_info.depth;
  435.     int bpp = depth >> 3;        /* bytes per pixel, 1 or 3 */
  436.     gx_color_index all_ones = ((gx_color_index)1 << depth) - 1;
  437.     gx_color_index strans =
  438.       (lop & lop_S_transparent ? all_ones : gx_no_color_index);
  439.     gx_color_index ttrans =
  440.       (lop & lop_T_transparent ? all_ones : gx_no_color_index);
  441.  
  442.     /* Check for constant source. */
  443.     if ( scolors != 0 && scolors[0] == scolors[1] )
  444.     {    /* Constant source */
  445.         const_source = scolors[0];
  446.         if ( const_source == 0 )
  447.           rop = rop3_know_S_0(rop);
  448.         else if ( const_source == all_ones )
  449.           rop = rop3_know_S_1(rop);
  450.     }
  451.     else if ( !rop3_uses_S(rop) )
  452.       const_source = 0;        /* arbitrary */
  453.  
  454.     /* Check for constant texture. */
  455.     if ( tcolors != 0 && tcolors[0] == tcolors[1] )
  456.     {    /* Constant texture */
  457.         const_texture = tcolors[0];
  458.         if ( const_texture == 0 )
  459.           rop = rop3_know_T_0(rop);
  460.         else if ( const_texture == all_ones )
  461.           rop = rop3_know_T_1(rop);
  462.     }
  463.     else if ( !rop3_uses_T(rop) )
  464.       const_texture = 0;        /* arbitrary */
  465.  
  466.     /* Adjust coordinates to be in bounds. */
  467.     if ( const_source == gx_no_color_index )
  468.     {    fit_copy(dev, sdata, sourcex, sraster, id,
  469.              x, y, width, height);
  470.     }
  471.     else
  472.     {    fit_fill(dev, x, y, width, height);
  473.     }
  474.  
  475.     /* Set up transfer parameters. */
  476.     line_count = height;
  477.     drow = scan_line_base(mdev, y) + x * bpp;
  478.  
  479.     /*
  480.      * There are 18 cases depending on whether each of the source and
  481.      * texture is constant, 1-bit, or multi-bit, and on whether the
  482.      * depth is 8 or 24 bits.  We divide first according to constant
  483.      * vs. non-constant, and then according to 1- vs. multi-bit, and
  484.      * finally according to pixel depth.  This minimizes source code,
  485.      * but not necessarily time, since we do some of the divisions
  486.      * within 1 or 2 levels of loop.
  487.      */
  488.  
  489. #define dbit(base, i) ((base)[(i) >> 3] & (0x80 >> ((i) & 7)))
  490. /* 8-bit */
  491. #define cbit8(base, i, colors)\
  492.   (dbit(base, i) ? (byte)colors[1] : (byte)colors[0])
  493. #define rop_body_8()\
  494.   if ( s_pixel == strans ||    /* So = 0, s_tr = 1 */\
  495.        t_pixel == ttrans    /* Po = 0, p_tr = 1 */\
  496.      )\
  497.     continue;\
  498.   *dptr = (*rop_proc_table[rop])(*dptr, s_pixel, t_pixel)
  499. /* 24-bit */
  500. #define get24(ptr)\
  501.   (((gx_color_index)(ptr)[0] << 16) | ((gx_color_index)(ptr)[1] << 8) | (ptr)[2])
  502. #define put24(ptr, pixel)\
  503.   (ptr)[0] = (byte)((pixel) >> 16),\
  504.   (ptr)[1] = (byte)((uint)(pixel) >> 8),\
  505.   (ptr)[2] = (byte)(pixel)
  506. #define cbit24(base, i, colors)\
  507.   (dbit(base, i) ? colors[1] : colors[0])
  508. #define rop_body_24()\
  509.   if ( s_pixel == strans ||    /* So = 0, s_tr = 1 */\
  510.        t_pixel == ttrans    /* Po = 0, p_tr = 1 */\
  511.      )\
  512.     continue;\
  513.   { gx_color_index d_pixel = get24(dptr);\
  514.     d_pixel = (*rop_proc_table[rop])(d_pixel, s_pixel, t_pixel);\
  515.     put24(dptr, d_pixel);\
  516.   }
  517.  
  518.     if ( const_texture != gx_no_color_index )    /**** Constant texture ****/
  519.       {
  520.         if ( const_source != gx_no_color_index )    /**** Constant source & texture ****/
  521.           {
  522.         for ( ; line_count-- > 0; drow += draster )
  523.           { byte *dptr = drow;
  524.             int left = width;
  525.             if ( bpp == 1 )    /**** 8-bit destination ****/
  526. #define s_pixel (byte)const_source
  527. #define t_pixel (byte)const_texture
  528.               for ( ; left > 0; ++dptr, --left )
  529.             { rop_body_8();
  530.             }
  531. #undef s_pixel
  532. #undef t_pixel
  533.             else        /**** 24-bit destination ****/
  534. #define s_pixel const_source
  535. #define t_pixel const_texture
  536.               for ( ; left > 0; dptr += 3, --left )
  537.             { rop_body_24();
  538.             }
  539. #undef s_pixel
  540. #undef t_pixel
  541.           }
  542.           }
  543.         else            /**** Data source, const texture ****/
  544.           { const byte *srow = sdata;
  545.         for ( ; line_count-- > 0; drow += draster, srow += sraster )
  546.           { byte *dptr = drow;
  547.             int left = width;
  548.             if ( scolors )    /**** 1-bit source ****/
  549.               {    int sx = sourcex;
  550.             if ( bpp == 1 )    /**** 8-bit destination ****/
  551. #define t_pixel (byte)const_texture
  552.               for ( ; left > 0; ++dptr, ++sx, --left )
  553.                 { byte s_pixel = cbit8(srow, sx, scolors);
  554.                   rop_body_8();
  555.                 }
  556. #undef t_pixel
  557.             else        /**** 24-bit destination ****/
  558. #define t_pixel const_texture
  559.               for ( ; left > 0; dptr += 3, ++sx, --left )
  560.                 { bits32 s_pixel = cbit24(srow, sx, scolors);
  561.                   rop_body_24();
  562.                 }
  563. #undef t_pixel
  564.               }
  565.             else if ( bpp == 1)    /**** 8-bit source & dest ****/
  566.               {    const byte *sptr = srow + sourcex;
  567. #define t_pixel (byte)const_texture
  568.             for ( ; left > 0; ++dptr, ++sptr, --left )
  569.               { byte s_pixel = *sptr;
  570.                 rop_body_8();
  571.               }
  572. #undef t_pixel
  573.               }
  574.             else        /**** 24-bit source & dest ****/
  575.               {    const byte *sptr = srow + sourcex * 3;
  576. #define t_pixel const_texture
  577.             for ( ; left > 0; dptr += 3, sptr += 3, --left )
  578.               { bits32 s_pixel = get24(sptr);
  579.                 rop_body_24();
  580.               }
  581. #undef t_pixel
  582.               }
  583.           }
  584.           }
  585.       }
  586.     else if ( const_source != gx_no_color_index )    /**** Const source, data texture ****/
  587.       {    uint traster = textures->raster;
  588.         int ty = y + phase_y;
  589.  
  590.         for ( ; line_count-- > 0; drow += draster, ++ty )
  591.           { /* Loop over copies of the tile. */
  592.             int dx = x, w = width, nw;
  593.             byte *dptr = drow;
  594.             const byte *trow =
  595.               textures->data + (ty % textures->size.y) * traster;
  596.             int xoff = x_offset(phase_x, ty, textures);
  597.  
  598.             for ( ; w > 0; dx += nw, w -= nw )
  599.               { int tx = (dx + xoff) % textures->rep_width;
  600.             int left = nw = min(w, textures->size.x - tx);
  601.             const byte *tptr = trow;
  602.  
  603.             if ( tcolors )    /**** 1-bit texture ****/
  604.               { if ( bpp == 1 )    /**** 8-bit dest ****/
  605. #define s_pixel (byte)const_source
  606.                   for ( ; left > 0; ++dptr, ++tx, --left )
  607.                 { byte t_pixel = cbit8(tptr, tx, tcolors);
  608.                   rop_body_8();
  609.                 }
  610. #undef s_pixel
  611.                 else        /**** 24-bit dest ****/
  612. #define s_pixel const_source
  613.                   for ( ; left > 0; dptr += 3, ++tx, --left )
  614.                 { bits32 t_pixel = cbit24(tptr, tx, tcolors);
  615.                   rop_body_24();
  616.                 }
  617. #undef s_pixel
  618.               }
  619.             else if ( bpp == 1 )    /**** 8-bit T & D ****/
  620.               { tptr += tx;
  621. #define s_pixel (byte)const_source
  622.                 for ( ; left > 0; ++dptr, ++tptr, --left )
  623.                   {    byte t_pixel = *tptr;
  624.                 rop_body_8();
  625.                   }
  626. #undef s_pixel
  627.               }
  628.             else            /**** 24-bit T & D ****/
  629.               { tptr += tx * 3;
  630. #define s_pixel const_source
  631.                 for ( ; left > 0; dptr += 3, tptr += 3, --left )
  632.                   {    bits32 t_pixel = get24(tptr);
  633.                 rop_body_24();
  634.                   }
  635. #undef s_pixel
  636.               }
  637.               }
  638.           }
  639.       }
  640.     else                /**** Data source & texture ****/
  641.       {
  642.     uint traster = textures->raster;
  643.     int ty = y + phase_y;
  644.     const byte *srow = sdata;
  645.  
  646.     /* Loop over scan lines. */
  647.     for ( ; line_count-- > 0; drow += draster, srow += sraster, ++ty )
  648.     {    /* Loop over copies of the tile. */
  649.         int sx = sourcex;
  650.         int dx = x;
  651.         int w = width;
  652.         int nw;
  653.         byte *dptr = drow;
  654.         const byte *trow =
  655.           textures->data + (ty % textures->size.y) * traster;
  656.         int xoff = x_offset(phase_x, ty, textures);
  657.  
  658.         for ( ; w > 0; dx += nw, w -= nw )
  659.         {    /* Loop over individual pixels. */
  660.             int tx = (dx + xoff) % textures->rep_width;
  661.             int left = nw = min(w, textures->size.x - tx);
  662.             const byte *tptr = trow;
  663.  
  664.             /*
  665.              * For maximum speed, we should split this loop
  666.              * into 7 cases depending on source & texture
  667.              * depth: (1,1), (1,8), (1,24), (8,1), (8,8),
  668.              * (24,1), (24,24).  But since we expect these
  669.              * cases to be relatively uncommon, we just
  670.              * divide on the destination depth.
  671.              */
  672.             if ( bpp == 1 )        /**** 8-bit destination ****/
  673.               { const byte *sptr = srow + sx;
  674.                 tptr += tx;
  675.                 for ( ; left > 0; ++dptr, ++sptr, ++tptr, ++sx, ++tx, --left )
  676.                   { byte s_pixel =
  677.                  (scolors ? cbit8(srow, sx, scolors) : *sptr);
  678.                 byte t_pixel =
  679.                  (tcolors ? cbit8(tptr, tx, tcolors) : *tptr);
  680.                 rop_body_8();
  681.                   }
  682.               }
  683.             else            /**** 24-bit destination ****/
  684.               { const byte *sptr = srow + sx * 3;
  685.                 tptr += tx * 3;
  686.                 for ( ; left > 0; dptr += 3, sptr += 3, tptr += 3, ++sx, ++tx, --left )
  687.                   { bits32 s_pixel =
  688.                   (scolors ? cbit24(srow, sx, scolors) :
  689.                    get24(sptr));
  690.                 bits32 t_pixel =
  691.                   (tcolors ? cbit24(tptr, tx, tcolors) :
  692.                    get24(tptr));
  693.                 rop_body_24();
  694.                   }
  695.               }
  696.         }
  697.     }
  698.     }
  699. #undef rop_body_8
  700. #undef rop_body_24
  701. #undef dbit
  702. #undef cbit8
  703. #undef cbit24
  704.     return 0;
  705. }
  706.  
  707. /* ---------------- Default copy_rop implementations ---------------- */
  708.  
  709. #undef mdev
  710.  
  711. int
  712. gx_real_default_copy_rop(gx_device *dev,
  713.   const byte *sdata, int sourcex, uint sraster, gx_bitmap_id id,
  714.   const gx_color_index *scolors,
  715.   const gx_tile_bitmap *texture, const gx_color_index *tcolors,
  716.   int x, int y, int width, int height,
  717.   int phase_x, int phase_y, gs_logical_operation_t lop)
  718. {    const gx_strip_bitmap *textures;
  719.     gx_strip_bitmap tiles;
  720.  
  721.     if ( texture == 0 )
  722.       textures = 0;
  723.     else
  724.       { *(gx_tile_bitmap *)&tiles = *texture;
  725.         tiles.rep_shift = tiles.shift = 0;
  726.         textures = &tiles;
  727.       }
  728.     return (*dev_proc(dev, strip_copy_rop))
  729.       (dev, sdata, sourcex, sraster, id, scolors, textures, tcolors,
  730.        x, y, width, height, phase_x, phase_y, lop);
  731. }
  732.  
  733. int
  734. gx_real_default_strip_copy_rop(gx_device *dev,
  735.   const byte *sdata, int sourcex, uint sraster, gx_bitmap_id id,
  736.   const gx_color_index *scolors,
  737.   const gx_strip_bitmap *textures, const gx_color_index *tcolors,
  738.   int x, int y, int width, int height,
  739.   int phase_x, int phase_y, gs_logical_operation_t lop)
  740. {    /*
  741.      * The default implementation uses get_bits to read out the
  742.      * pixels, the memory device implementation to do the operation,
  743.      * and copy_color to write the pixels back.
  744.      */
  745.     int depth = dev->color_info.depth;
  746.     const gx_device_memory *mdproto = gdev_mem_device_for_bits(depth);
  747.     gx_device_memory mdev;
  748.     uint draster = gx_device_raster(dev, true);
  749.     bool uses_d = rop3_uses_D(gs_transparent_rop(lop));
  750.     byte *row;
  751.     int code;
  752.     int py;
  753.  
  754. #ifdef DEBUG
  755.     if ( gs_debug_c('b') )
  756.       trace_copy_rop("gx_default_strip_copy_rop",
  757.              dev, sdata, sourcex, sraster,
  758.              id, scolors, textures, tcolors,
  759.              x, y, width, height, phase_x, phase_y, lop);
  760. #endif
  761.     if ( mdproto == 0 )
  762.       return_error(gs_error_rangecheck);
  763.     if ( sdata == 0 )
  764.       { fit_fill(dev, x, y, width, height);
  765.       }
  766.     else
  767.       { fit_copy(dev, sdata, sourcex, sraster, id, x, y, width, height);
  768.       }
  769.     gs_make_mem_device(&mdev, mdproto, 0, -1, dev);
  770.     mdev.width = width;
  771.     mdev.height = 1;
  772.     mdev.bitmap_memory = &gs_memory_default;
  773.     code = (*dev_proc(&mdev, open_device))((gx_device *)&mdev);
  774.     if ( code < 0 )
  775.       return code;
  776.     row = gs_malloc(1, draster, "copy_rop buffer");
  777.     if ( row == 0 )
  778.       { (*dev_proc(&mdev, close_device))((gx_device *)&mdev);
  779.         return_error(gs_error_VMerror);
  780.       }
  781.     for ( py = y; py < y + height; ++py )
  782.       { byte *data;
  783.  
  784.         if ( uses_d )
  785.           { code = (*dev_proc(dev, get_bits))(dev, py, row, &data);
  786.         if ( code < 0 )
  787.           break;
  788.         code = (*dev_proc(&mdev, copy_color))((gx_device *)&mdev,
  789.             data, x, draster, gx_no_bitmap_id,
  790.             0, 0, width, 1);
  791.         if ( code < 0 )
  792.           return code;
  793.           }
  794.         code = (*dev_proc(&mdev, strip_copy_rop))((gx_device *)&mdev,
  795.             sdata + (py - y) * sraster, sourcex, sraster,
  796.             gx_no_bitmap_id, scolors, textures, tcolors,
  797.             0, 0, width, 1, phase_x + x, phase_y + py,
  798.             lop);
  799.         if ( code < 0 )
  800.           break;
  801.         code = (*dev_proc(&mdev, get_bits))((gx_device *)&mdev, 0, row, &data);
  802.         if ( code < 0 )
  803.           break;
  804.         code = (*dev_proc(dev, copy_color))(dev,
  805.             data, 0, draster, gx_no_bitmap_id,
  806.             x, py, width, 1);
  807.         if ( code < 0 )
  808.           break;
  809.       }
  810.     gs_free(row, 1, draster, "copy_rop buffer");
  811.     (*dev_proc(&mdev, close_device))((gx_device *)&mdev);
  812.     return code;
  813. }
  814.  
  815. int
  816. gx_forward_copy_rop(gx_device *dev,
  817.   const byte *sdata, int sourcex, uint sraster, gx_bitmap_id id,
  818.   const gx_color_index *scolors,
  819.   const gx_tile_bitmap *texture, const gx_color_index *tcolors,
  820.   int x, int y, int width, int height,
  821.   int phase_x, int phase_y, gs_logical_operation_t lop)
  822. {    gx_device *tdev = ((gx_device_forward *)dev)->target;
  823.     dev_proc_copy_rop((*proc));
  824.  
  825.     if ( tdev == 0 )
  826.       tdev = dev, proc = gx_default_copy_rop;
  827.     else
  828.       proc = dev_proc(tdev, copy_rop);
  829.     return (*proc)(tdev, sdata, sourcex, sraster, id, scolors,
  830.                texture, tcolors, x, y, width, height,
  831.                phase_x, phase_y, lop);
  832. }
  833.  
  834. int
  835. gx_forward_strip_copy_rop(gx_device *dev,
  836.   const byte *sdata, int sourcex, uint sraster, gx_bitmap_id id,
  837.   const gx_color_index *scolors,
  838.   const gx_strip_bitmap *textures, const gx_color_index *tcolors,
  839.   int x, int y, int width, int height,
  840.   int phase_x, int phase_y, gs_logical_operation_t lop)
  841. {    gx_device *tdev = ((gx_device_forward *)dev)->target;
  842.     dev_proc_strip_copy_rop((*proc));
  843.  
  844.     if ( tdev == 0 )
  845.       tdev = dev, proc = gx_default_strip_copy_rop;
  846.     else
  847.       proc = dev_proc(tdev, strip_copy_rop);
  848.     return (*proc)(tdev, sdata, sourcex, sraster, id, scolors,
  849.                textures, tcolors, x, y, width, height,
  850.                phase_x, phase_y, lop);
  851. }
  852.  
  853. int
  854. gx_copy_rop_unaligned(gx_device *dev,
  855.   const byte *sdata, int sourcex, uint sraster, gx_bitmap_id id,
  856.   const gx_color_index *scolors,
  857.   const gx_tile_bitmap *texture, const gx_color_index *tcolors,
  858.   int x, int y, int width, int height,
  859.   int phase_x, int phase_y, gs_logical_operation_t lop)
  860. {    const gx_strip_bitmap *textures;
  861.     gx_strip_bitmap tiles;
  862.  
  863.     if ( texture == 0 )
  864.       textures = 0;
  865.     else
  866.       { *(gx_tile_bitmap *)&tiles = *texture;
  867.         tiles.rep_shift = tiles.shift = 0;
  868.         textures = &tiles;
  869.       }
  870.     return gx_strip_copy_rop_unaligned
  871.       (dev, sdata, sourcex, sraster, id, scolors, textures, tcolors,
  872.        x, y, width, height, phase_x, phase_y, lop);
  873. }
  874.  
  875. int
  876. gx_strip_copy_rop_unaligned(gx_device *dev,
  877.   const byte *sdata, int sourcex, uint sraster, gx_bitmap_id id,
  878.   const gx_color_index *scolors,
  879.   const gx_strip_bitmap *textures, const gx_color_index *tcolors,
  880.   int x, int y, int width, int height,
  881.   int phase_x, int phase_y, gs_logical_operation_t lop)
  882. {    dev_proc_strip_copy_rop((*copy_rop)) = dev_proc(dev, strip_copy_rop);
  883.     int depth = (scolors == 0 ? dev->color_info.depth : 1);
  884.     int step = sraster & (align_bitmap_mod - 1);
  885.  
  886.     /* Adjust the origin. */
  887.     if ( sdata != 0 )
  888.       { uint offset =
  889.           (uint)(sdata - (const byte *)0) & (align_bitmap_mod - 1);
  890.         /* See copy_color above re the following statement. */
  891.         if ( depth == 24 )
  892.           offset += (offset % 3) *
  893.         (align_bitmap_mod * (3 - (align_bitmap_mod % 3)));
  894.         sdata -= offset;
  895.         sourcex += (offset << 3) / depth;
  896.       }
  897.  
  898.     /* Adjust the raster. */
  899.     if ( !step || sdata == 0 ||
  900.          (scolors != 0 && scolors[0] == scolors[1])
  901.        )
  902.       { /* No adjustment needed. */
  903.         return (*copy_rop)(dev, sdata, sourcex, sraster, id, scolors,
  904.                    textures, tcolors, x, y, width, height,
  905.                    phase_x, phase_y, lop);
  906.       }
  907.  
  908.     /* Do the transfer one scan line at a time. */
  909.     { const byte *p = sdata;
  910.       int d = sourcex;
  911.       int dstep = (step << 3) / depth;
  912.       int code = 0;
  913.       int i;
  914.  
  915.       for ( i = 0; i < height && code >= 0;
  916.             ++i, p += sraster - step, d += dstep
  917.           )
  918.         code = (*copy_rop)(dev, p, d, sraster, gx_no_bitmap_id, scolors,
  919.                    textures, tcolors, x, y + i, width, 1,
  920.                    phase_x, phase_y, lop);
  921.       return code;
  922.     }
  923. }
  924.  
  925. /* ---------------- RasterOp texture device ---------------- */
  926.  
  927. public_st_device_rop_texture();
  928.  
  929. /* Device for clipping with a region. */
  930. private dev_proc_fill_rectangle(rop_texture_fill_rectangle);
  931. private dev_proc_copy_mono(rop_texture_copy_mono);
  932. private dev_proc_copy_color(rop_texture_copy_color);
  933.  
  934. /* The device descriptor. */
  935. private const gx_device_rop_texture far_data gs_rop_texture_device =
  936. {    std_device_std_body(gx_device_rop_texture, 0, "rop source",
  937.       0, 0, 1, 1),
  938.     {    NULL,        /* open_device */
  939.         gx_forward_get_initial_matrix,
  940.         NULL,        /* default_sync_output */
  941.         NULL,        /* output_page */
  942.         NULL,        /* close_device */
  943.         gx_forward_map_rgb_color,
  944.         gx_forward_map_color_rgb,
  945.         rop_texture_fill_rectangle,
  946.         NULL,        /* tile_rectangle */
  947.         rop_texture_copy_mono,
  948.         rop_texture_copy_color,
  949.         NULL,        /* draw_line */
  950.         NULL,        /* get_bits */
  951.         gx_forward_get_params,
  952.         gx_forward_put_params,
  953.         gx_forward_map_cmyk_color,
  954.         gx_forward_get_xfont_procs,
  955.         gx_forward_get_xfont_device,
  956.         gx_forward_map_rgb_alpha_color,
  957.         gx_forward_get_page_device,
  958.         NULL,        /* get_alpha_bits (no alpha) */
  959.         gx_no_copy_alpha,        /* shouldn't be called */
  960.         gx_forward_get_band,
  961.         gx_no_copy_rop,            /* shouldn't be called */
  962.         NULL,        /* fill_path */
  963.         NULL,        /* stroke_path */
  964.         NULL,        /* fill_mask */
  965.         NULL,        /* fill_trapezoid */
  966.         NULL,        /* fill_parallelogram */
  967.         NULL,        /* fill_triangle */
  968.         NULL,        /* draw_thin_line */
  969.         NULL,        /* begin_image */
  970.         NULL,        /* image_data */
  971.         NULL,        /* end_image */
  972.         NULL,        /* strip_tile_rectangle */
  973.         NULL,        /* strip_copy_rop */
  974.         gx_forward_get_clipping_box
  975.     },
  976.     0,            /* target */
  977.     lop_default,        /* log_op */
  978.     NULL            /* texture */
  979. };
  980. #define rtdev ((gx_device_rop_texture *)dev)
  981.  
  982. /* Initialize a RasterOp source device. */
  983. void
  984. gx_make_rop_texture_device(gx_device_rop_texture *dev, gx_device *target,
  985.   gs_logical_operation_t log_op, const gx_device_color *texture)
  986. {    *dev = gs_rop_texture_device;
  987.     /* Drawing operations are defaulted, non-drawing are forwarded. */
  988.     gx_device_fill_in_procs((gx_device *)dev);
  989.     dev->color_info = target->color_info;
  990.     dev->target = target;
  991.     dev->log_op = log_op;
  992.     dev->texture = texture;
  993. }
  994.  
  995. /* Fill a rectangle */
  996. private int
  997. rop_texture_fill_rectangle(gx_device *dev, int x, int y, int w, int h,
  998.   gx_color_index color)
  999. {    gx_rop_source_t source;
  1000.  
  1001.     source.sdata = NULL;
  1002.     source.sourcex = 0;
  1003.     source.sraster = 0;
  1004.     source.id = gx_no_bitmap_id;
  1005.     source.scolors[0] = source.scolors[1] = color;
  1006.     source.use_scolors = true;
  1007.     return gx_device_color_fill_rectangle(rtdev->texture,
  1008.                 x, y, w, h, rtdev->target,
  1009.                 rtdev->log_op, &source);
  1010. }
  1011.  
  1012. /* Copy a monochrome rectangle */
  1013. private int
  1014. rop_texture_copy_mono(gx_device *dev,
  1015.   const byte *data, int sourcex, int raster, gx_bitmap_id id,
  1016.   int x, int y, int w, int h,
  1017.   gx_color_index color0, gx_color_index color1)
  1018. {    gx_rop_source_t source;
  1019.     gs_logical_operation_t lop = rtdev->log_op;
  1020.  
  1021.     source.sdata = data;
  1022.     source.sourcex = sourcex;
  1023.     source.sraster = raster;
  1024.     source.id = id;
  1025.     source.scolors[0] = color0;
  1026.     source.scolors[1] = color1;
  1027.     source.use_scolors = true;
  1028.     /* Adjust the logical operation per transparent colors. */
  1029.     if ( color0 == gx_no_color_index )
  1030.       lop = rop3_use_D_when_S_0(lop);
  1031.     else if ( color1 == gx_no_color_index )
  1032.       lop = rop3_use_D_when_S_1(lop);
  1033.     return gx_device_color_fill_rectangle(rtdev->texture,
  1034.                 x, y, w, h, rtdev->target,
  1035.                 lop, &source);
  1036. }
  1037.  
  1038. /* Copy a color rectangle */
  1039. private int
  1040. rop_texture_copy_color(gx_device *dev,
  1041.   const byte *data, int sourcex, int raster, gx_bitmap_id id,
  1042.   int x, int y, int w, int h)
  1043. {    gx_rop_source_t source;
  1044.  
  1045.     source.sdata = data;
  1046.     source.sourcex = sourcex;
  1047.     source.sraster = raster;
  1048.     source.id = id;
  1049.     source.scolors[0] = source.scolors[1] = gx_no_color_index;
  1050.     source.use_scolors = true;
  1051.     return gx_device_color_fill_rectangle(rtdev->texture,
  1052.                 x, y, w, h, rtdev->target,
  1053.                 rtdev->log_op, &source);
  1054. }
  1055.  
  1056. /* ---------------- Internal routines ---------------- */
  1057.  
  1058. /* Compute the effective RasterOp for the 1-bit case, */
  1059. /* taking transparency into account. */
  1060. private gs_rop3_t
  1061. gs_transparent_rop(gs_logical_operation_t lop)
  1062. {    gs_rop3_t rop = lop_rop(lop);
  1063.     /*
  1064.      * The algorithm for computing an effective RasterOp is presented,
  1065.      * albeit obfuscated, in the H-P PCL5 technical documentation.
  1066.      * Define So ("source opaque") and Po ("pattern opaque") as masks
  1067.      * that have 1-bits precisely where the source or pattern
  1068.      * respectively are not white (transparent).
  1069.      * One applies the original RasterOp to compute an intermediate
  1070.      * result R, and then computes the final result as
  1071.      * (R & M) | (D & ~M) where M depends on transparencies as follows:
  1072.      *    s_tr    p_tr    M
  1073.      *     0     0    1
  1074.      *     0     1    ~So | Po (? Po ?)
  1075.      *     1     0    So
  1076.      *     1     1    So & Po
  1077.      * The s_tr = 0, p_tr = 1 case seems wrong, but it's clearly
  1078.      * specified that way in the "PCL 5 Color Technical Reference
  1079.      * Manual."
  1080.      *
  1081.      * In the 1-bit case, So = ~S and Po = ~P, so we can apply the
  1082.      * above table directly.
  1083.      */
  1084. #define So rop3_not(rop3_S)
  1085. #define Po rop3_not(rop3_T)
  1086. #ifdef TRANSPARENCY_PER_H_P
  1087. #  define MPo (rop3_uses_S(rop) ? rop3_not(So) | Po : Po)
  1088. #else
  1089. #  define MPo Po
  1090. #endif
  1091.     /*
  1092.      * If the operation doesn't use S or T, we must disregard the
  1093.      * corresponding transparency flag.
  1094.      */
  1095. #define source_transparent ((lop & lop_S_transparent) && rop3_uses_S(rop))
  1096. #define pattern_transparent ((lop & lop_T_transparent) && rop3_uses_T(rop))
  1097.     gs_rop3_t mask =
  1098.       (source_transparent ?
  1099.        (pattern_transparent ? So & Po : So) :
  1100.        (pattern_transparent ? MPo : rop3_1));
  1101. #undef MPo
  1102.     return (rop & mask) | (rop3_D & ~mask);
  1103. }
  1104.